TypeScript Yordamchi Tiplarini O'zlashtirish: Global Dasturchilar uchun Amaliy Qo'llanma

            
interface Customer {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  phoneNumber: string;
  address: {
    street: string;
    city: string;
    country: string;
    postalCode: string;
  };
  preferences?: {
    language: string;
    currency: string;
  }
}

            

              
                Copy
              
            
          

            
type PartialCustomer = Partial<Customer>;

function updateCustomer(id: string, updates: PartialCustomer): void {
  // ... mijozni berilgan ID bilan yangilash uchun implementatsiya
}

updateCustomer("123", { firstName: "John", lastName: "Doe" }); // To'g'ri
updateCustomer("456", { address: { city: "London" } }); // To'g'ri

            

              
                Copy
              
            
          

            
interface AppConfig {
  apiUrl: string;
  theme: string;
  supportedLanguages: string[];
  version: string; // Versiya qo'shildi
}

const config: AppConfig = {
  apiUrl: "https://api.example.com",
  theme: "dark",
  supportedLanguages: ["en", "fr", "de", "es", "zh"],
  version: "1.0.0"
};

            

              
                Copy
              
            
          

            
type ReadonlyAppConfig = Readonly<AppConfig>;

const readonlyConfig: ReadonlyAppConfig = {
  apiUrl: "https://api.example.com",
  theme: "dark",
  supportedLanguages: ["en", "fr", "de", "es", "zh"],
  version: "1.0.0"
};

// readonlyConfig.apiUrl = "https://newapi.example.com"; // Xato: 'apiUrl'ga qiymat berib bo'lmaydi, chunki u faqat o'qish uchun mo'ljallangan xususiyat.

            

              
                Copy
              
            
          

            
interface Event {
  id: string;
  title: string;
  description: string;
  location: string;
  startTime: Date;
  endTime: Date;
  organizer: string;
  attendees: string[];
}

            

              
                Copy
              
            
          

            
type EventSummary = Pick<Event, "title" | "location" | "startTime">;

function displayEventSummary(event: EventSummary): void {
  console.log(`Tadbir: ${event.title} manzili ${event.location} vaqti ${event.startTime}`);
}

            

              
                Copy
              
            
          

            
type NewEvent = Omit<Event, "id">;

function createEvent(event: NewEvent): void {
  // ... yangi tadbir yaratish uchun implementatsiya
}

            

              
                Copy
              
            
          

            
type Translations = Record<string, string>;

const enTranslations: Translations = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our platform!"
};

const frTranslations: Translations = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre plateforme !"
};

function translate(key: string, language: string): string {
  const translations = language === "en" ? enTranslations : frTranslations; // Soddalashtirilgan
  return translations[key] || key; // Agar tarjima topilmasa, kalitni qaytarish
}

console.log(translate("hello", "en")); // Chiqish: Hello
console.log(translate("hello", "fr")); // Chiqish: Bonjour
console.log(translate("nonexistent", "en")); // Chiqish: nonexistent

            

              
                Copy
              
            
          

            
type EventType = "concert" | "conference" | "workshop" | "webinar";

            

              
                Copy
              
            
          

            
type PhysicalEvent = Exclude<EventType, "webinar">;

// PhysicalEvent endi "concert" | "conference" | "workshop"

function attendPhysicalEvent(event: PhysicalEvent): void {
  console.log(`${event}ga tashrif buyurish`);
}

// attendPhysicalEvent("webinar"); // Xato: '"webinar"' turidagi argument '"concert" | "conference" | "workshop"' turidagi parametrga tayinlanmaydi.

attendPhysicalEvent("concert"); // To'g'ri

            

              
                Copy
              
            
          

            
type OnlineEvent = Extract<EventType, "webinar">;

// OnlineEvent endi "webinar"

function attendOnlineEvent(event: OnlineEvent): void {
  console.log(`${event}ga onlayn tashrif buyurish`);
}

attendOnlineEvent("webinar"); // To'g'ri
// attendOnlineEvent("concert"); // Xato: '"concert"' turidagi argument '"webinar"' turidagi parametrga tayinlanmaydi.

            

              
                Copy
              
            
          

            
type MaybeString = string | null | undefined;

type DefinitelyString = NonNullable<MaybeString>;

// DefinitelyString endi string

function processString(str: DefinitelyString): void {
  console.log(str.toUpperCase());
}

// processString(null); // Xato: 'null' turidagi argument 'string' turidagi parametrga tayinlanmaydi.
// processString(undefined); // Xato: 'undefined' turidagi argument 'string' turidagi parametrga tayinlanmaydi.
processString("hello"); // To'g'ri

            

              
                Copy
              
            
          

            
function greet(name: string): string {
  return `Hello, ${name}!`;
}

type Greeting = ReturnType<typeof greet>;

// Greeting endi string

const message: Greeting = greet("World");

console.log(message);

            

              
                Copy
              
            
          

            
function logEvent(eventName: string, eventData: object): void {
  console.log(`Tadbir: ${eventName}`, eventData);
}

type LogEventParams = Parameters<typeof logEvent>;

// LogEventParams endi [eventName: string, eventData: object]

const params: LogEventParams = ["user_login", { userId: "123", timestamp: Date.now() }];

logEvent(...params);

            

              
                Copy
              
            
          

            
class Greeter {
  greeting: string;

  constructor(message: string) {
    this.greeting = message;
  }

  greet() {
    return "Hello, " + this.greeting;
  }
}


type GreeterParams = ConstructorParameters<typeof Greeter>;

// GreeterParams endi [message: string]

const paramsGreeter: GreeterParams = ["World"];
const greeterInstance = new Greeter(...paramsGreeter);

console.log(greeterInstance.greet()); // Chiqish: Hello, World

            

              
                Copy
              
            
          

            
interface UserProfile {
  name: string;
  age?: number;
  email?: string;
}

type RequiredUserProfile = Required<UserProfile>;

// RequiredUserProfile endi { name: string; age: number; email: string; }

const completeProfile: RequiredUserProfile = {
  name: "Alice",
  age: 30,
  email: "alice@example.com"
};

// const incompleteProfile: RequiredUserProfile = { name: "Bob" }; // Xato: '{ name: string; }' tipida 'age' xususiyati yo'q, lekin 'Required' tipida talab qilinadi.

            

              
                Copy
              
            
          

            
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type APIEndpoint = `/api/users` | `/api/products`;

type RequestURL = `${HTTPMethod} ${APIEndpoint}`;

// RequestURL endi "GET /api/users" | "POST /api/users" | ... va hokazo

function makeRequest(url: RequestURL): void {
  console.log(`${url} ga so'rov yuborilmoqda`);
}

makeRequest("GET /api/users"); // To'g'ri
// makeRequest("INVALID /api/users"); // Xato

            

              
                Copy
              
            
          

            
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

// Agar T Promise bo'lsa, unda tip U bo'ladi; aks holda, tip T bo'ladi.

async function fetchData(): Promise<number> {
  return 42;
}


type Data = UnwrapPromise<ReturnType<typeof fetchData>>;

// Data endi number

function processData(data: Data): void {
  console.log(data * 2);
}

processData(await fetchData());

            

              
                Copy